{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !wget https://storage.googleapis.com/bert_models/2018_10_18/uncased_L-12_H-768_A-12.zip\n",
    "# !unzip uncased_L-12_H-768_A-12.zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "BERT_VOCAB = 'uncased_L-12_H-768_A-12/vocab.txt'\n",
    "BERT_INIT_CHKPNT = 'uncased_L-12_H-768_A-12/bert_model.ckpt'\n",
    "BERT_CONFIG = 'uncased_L-12_H-768_A-12/bert_config.json'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import bert\n",
    "from bert import run_classifier\n",
    "from bert import optimization\n",
    "from bert import tokenization\n",
    "from bert import modeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenization.validate_case_matches_checkpoint(True,BERT_INIT_CHKPNT)\n",
    "tokenizer = tokenization.FullTokenizer(\n",
    "      vocab_file=BERT_VOCAB, do_lower_case=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/husein/.local/lib/python3.6/site-packages/sklearn/cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "from utils import *\n",
    "import tensorflow as tf\n",
    "from sklearn.cross_validation import train_test_split\n",
    "import time\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['negative', 'positive']\n",
      "10662\n",
      "10662\n"
     ]
    }
   ],
   "source": [
    "trainset = sklearn.datasets.load_files(container_path = 'data', encoding = 'UTF-8')\n",
    "trainset.data, trainset.target = separate_dataset(trainset,1.0)\n",
    "print (trainset.target_names)\n",
    "print (len(trainset.data))\n",
    "print (len(trainset.target))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_SEQ_LENGTH = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10662/10662 [00:03<00:00, 3547.96it/s]\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "input_ids, input_masks, segment_ids = [], [], []\n",
    "\n",
    "for text in tqdm(trainset.data):\n",
    "    tokens_a = tokenizer.tokenize(text)\n",
    "    if len(tokens_a) > MAX_SEQ_LENGTH - 2:\n",
    "        tokens_a = tokens_a[:(MAX_SEQ_LENGTH - 2)]\n",
    "    tokens = [\"[CLS]\"] + tokens_a + [\"[SEP]\"]\n",
    "    segment_id = [0] * len(tokens)\n",
    "    input_id = tokenizer.convert_tokens_to_ids(tokens)\n",
    "    input_mask = [1] * len(input_id)\n",
    "    padding = [0] * (MAX_SEQ_LENGTH - len(input_id))\n",
    "    input_id += padding\n",
    "    input_mask += padding\n",
    "    segment_id += padding\n",
    "    \n",
    "    input_ids.append(input_id)\n",
    "    input_masks.append(input_mask)\n",
    "    segment_ids.append(segment_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_X, test_X, train_Y, test_Y = train_test_split(input_ids, trainset.target,\n",
    "                                                    test_size = 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _pairwise_distances(embeddings, squared=False):\n",
    "    dot_product = tf.matmul(embeddings, tf.transpose(embeddings))\n",
    "    square_norm = tf.diag_part(dot_product)\n",
    "    distances = tf.expand_dims(square_norm, 1) - 2.0 * dot_product + tf.expand_dims(square_norm, 0)\n",
    "    distances = tf.maximum(distances, 0.0)\n",
    "\n",
    "    if not squared:\n",
    "        mask = tf.to_float(tf.equal(distances, 0.0))\n",
    "        distances = distances + mask * 1e-16\n",
    "        distances = tf.sqrt(distances)\n",
    "        distances = distances * (1.0 - mask)\n",
    "\n",
    "    return distances\n",
    "\n",
    "\n",
    "def _get_anchor_positive_triplet_mask(labels):\n",
    "    indices_equal = tf.cast(tf.eye(tf.shape(labels)[0]), tf.bool)\n",
    "    indices_not_equal = tf.logical_not(indices_equal)\n",
    "    labels_equal = tf.equal(tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))\n",
    "    mask = tf.logical_and(indices_not_equal, labels_equal)\n",
    "\n",
    "    return mask\n",
    "\n",
    "\n",
    "def _get_anchor_negative_triplet_mask(labels):\n",
    "    labels_equal = tf.equal(tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))\n",
    "    mask = tf.logical_not(labels_equal)\n",
    "\n",
    "    return mask\n",
    "\n",
    "\n",
    "def _get_triplet_mask(labels):\n",
    "    indices_equal = tf.cast(tf.eye(tf.shape(labels)[0]), tf.bool)\n",
    "    indices_not_equal = tf.logical_not(indices_equal)\n",
    "    i_not_equal_j = tf.expand_dims(indices_not_equal, 2)\n",
    "    i_not_equal_k = tf.expand_dims(indices_not_equal, 1)\n",
    "    j_not_equal_k = tf.expand_dims(indices_not_equal, 0)\n",
    "\n",
    "    distinct_indices = tf.logical_and(tf.logical_and(i_not_equal_j, i_not_equal_k), j_not_equal_k)\n",
    "\n",
    "    label_equal = tf.equal(tf.expand_dims(labels, 0), tf.expand_dims(labels, 1))\n",
    "    i_equal_j = tf.expand_dims(label_equal, 2)\n",
    "    i_equal_k = tf.expand_dims(label_equal, 1)\n",
    "\n",
    "    valid_labels = tf.logical_and(i_equal_j, tf.logical_not(i_equal_k))\n",
    "    mask = tf.logical_and(distinct_indices, valid_labels)\n",
    "\n",
    "    return mask\n",
    "\n",
    "\n",
    "def batch_all_triplet_loss(labels, embeddings, margin, squared=False):\n",
    "    pairwise_dist = _pairwise_distances(embeddings, squared=squared)\n",
    "\n",
    "    # shape (batch_size, batch_size, 1)\n",
    "    anchor_positive_dist = tf.expand_dims(pairwise_dist, 2)\n",
    "    assert anchor_positive_dist.shape[2] == 1, \"{}\".format(anchor_positive_dist.shape)\n",
    "    # shape (batch_size, 1, batch_size)\n",
    "    anchor_negative_dist = tf.expand_dims(pairwise_dist, 1)\n",
    "    assert anchor_negative_dist.shape[1] == 1, \"{}\".format(anchor_negative_dist.shape)\n",
    "\n",
    "    triplet_loss = anchor_positive_dist - anchor_negative_dist + margin\n",
    "\n",
    "    mask = _get_triplet_mask(labels)\n",
    "    mask = tf.to_float(mask)\n",
    "    triplet_loss = tf.multiply(mask, triplet_loss)\n",
    "\n",
    "    # Remove negative losses (i.e. the easy triplets)\n",
    "    triplet_loss = tf.maximum(triplet_loss, 0.0)\n",
    "\n",
    "    # Count number of positive triplets (where triplet_loss > 0)\n",
    "    valid_triplets = tf.to_float(tf.greater(triplet_loss, 1e-16))\n",
    "    num_positive_triplets = tf.reduce_sum(valid_triplets)\n",
    "    num_valid_triplets = tf.reduce_sum(mask)\n",
    "    fraction_positive_triplets = num_positive_triplets / (num_valid_triplets + 1e-16)\n",
    "\n",
    "    # Get final mean triplet loss over the positive valid triplets\n",
    "    triplet_loss = tf.reduce_sum(triplet_loss) / (num_positive_triplets + 1e-16)\n",
    "\n",
    "    return triplet_loss, fraction_positive_triplets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "bert_config = modeling.BertConfig.from_json_file(BERT_CONFIG)\n",
    "epoch = 10\n",
    "batch_size = 3\n",
    "warmup_proportion = 0.1\n",
    "num_train_steps = int(len(input_ids) / batch_size * epoch)\n",
    "num_warmup_steps = int(num_train_steps * warmup_proportion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(self, dimension_output):\n",
    "        \n",
    "        self.X = tf.placeholder(tf.int32, [None, None])\n",
    "        self.Y = tf.placeholder(tf.int32, [None])\n",
    "        \n",
    "        model = modeling.BertModel(\n",
    "            config=bert_config,\n",
    "            is_training=True,\n",
    "            input_ids=self.X,\n",
    "            use_one_hot_embeddings=False)\n",
    "        \n",
    "        output_layer = model.get_pooled_output()\n",
    "        self.logits = tf.layers.dense(output_layer, dimension_output)\n",
    "        self.cost, fraction = batch_all_triplet_loss(self.Y, self.logits, margin=0.5, squared=False)\n",
    "        \n",
    "        self.optimizer = optimization.create_optimizer(self.cost, 2e-5, \n",
    "                                                       num_train_steps, num_warmup_steps, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "sess = tf.InteractiveSession()\n",
    "model = Model(2)\n",
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from uncased_L-12_H-768_A-12/bert_model.ckpt\n"
     ]
    }
   ],
   "source": [
    "var_lists = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope = 'bert')\n",
    "saver = tf.train.Saver(var_list = var_lists)\n",
    "saver.restore(sess, BERT_INIT_CHKPNT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train minibatch loop: 100%|██████████| 2843/2843 [14:03<00:00,  3.36it/s, cost=0.322] \n",
      "train minibatch loop:   0%|          | 0/2843 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1, avg cost: 0.372676\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train minibatch loop: 100%|██████████| 2843/2843 [14:02<00:00,  3.36it/s, cost=0.467]\n",
      "train minibatch loop:   0%|          | 0/2843 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 2, avg cost: 0.366336\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train minibatch loop: 100%|██████████| 2843/2843 [14:03<00:00,  3.36it/s, cost=0.509]\n",
      "train minibatch loop:   0%|          | 0/2843 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 3, avg cost: 0.368754\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train minibatch loop: 100%|██████████| 2843/2843 [14:04<00:00,  3.37it/s, cost=0.513]\n",
      "train minibatch loop:   0%|          | 0/2843 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 4, avg cost: 0.368195\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train minibatch loop: 100%|██████████| 2843/2843 [14:04<00:00,  3.36it/s, cost=0.506]\n",
      "train minibatch loop:   0%|          | 0/2843 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 5, avg cost: 0.368211\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train minibatch loop: 100%|██████████| 2843/2843 [14:04<00:00,  3.35it/s, cost=0.524]\n",
      "train minibatch loop:   0%|          | 0/2843 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 6, avg cost: 0.368046\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train minibatch loop: 100%|██████████| 2843/2843 [14:04<00:00,  3.36it/s, cost=0.482]\n",
      "train minibatch loop:   0%|          | 0/2843 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 7, avg cost: 0.367200\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train minibatch loop: 100%|██████████| 2843/2843 [14:04<00:00,  3.36it/s, cost=0.528]\n",
      "train minibatch loop:   0%|          | 0/2843 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 8, avg cost: 0.368411\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train minibatch loop: 100%|██████████| 2843/2843 [14:04<00:00,  3.37it/s, cost=0.525]\n",
      "train minibatch loop:   0%|          | 0/2843 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 9, avg cost: 0.368011\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train minibatch loop: 100%|██████████| 2843/2843 [14:04<00:00,  3.37it/s, cost=0.483]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 10, avg cost: 0.368287\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "for e in range(10):\n",
    "    total_loss = 0\n",
    "    pbar = tqdm(\n",
    "        range(0,len(train_X),batch_size), desc = 'train minibatch loop'\n",
    "    )\n",
    "    for index in pbar:\n",
    "        \n",
    "        batch_x = train_X[index:min(index+batch_size,len(train_X))]\n",
    "        batch_y = train_Y[index:min(index+batch_size,len(train_X))]\n",
    "        loss, _ = sess.run([model.cost,model.optimizer],feed_dict={model.X:batch_x,model.Y:batch_y})\n",
    "        total_loss += loss\n",
    "        pbar.set_postfix(cost = loss)\n",
    "    total_loss /= len(train_X) / batch_size\n",
    "    print('epoch: %d, avg cost: %f'%(e+1,total_loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8529, 2)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits_train = []\n",
    "\n",
    "for index in range(0,len(train_X),batch_size):\n",
    "    batch_x = train_X[index:min(index+batch_size,len(train_X))]\n",
    "    l = sess.run(model.logits,feed_dict={model.X:batch_x})\n",
    "    logits_train.extend(l.tolist())\n",
    "    \n",
    "logits_train = np.array(logits_train)\n",
    "logits_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2133, 2)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits_test = []\n",
    "\n",
    "for index in range(0,len(test_X),batch_size):\n",
    "    batch_x = test_X[index:min(index+batch_size,len(test_X))]\n",
    "    l = sess.run(model.logits,feed_dict={model.X:batch_x})\n",
    "    logits_test.extend(l.tolist())\n",
    "    \n",
    "logits_test = np.array(logits_test)\n",
    "logits_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()\n",
    "from matplotlib import offsetbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax_min = np.min(logits_test,0)\n",
    "ax_max = np.max(logits_test,0)\n",
    "ax_dist_sq = np.sum((ax_max-ax_min)**2)\n",
    "plt.figure(figsize=(8,8))\n",
    "ax = plt.subplot(111)\n",
    "shown_images = np.array([[1., 1.]])\n",
    "colors = ['b','r']\n",
    "for i in range(logits_test.shape[0]):\n",
    "    dist = np.sum((logits_test[i] - shown_images)**2, 1)\n",
    "    if np.min(dist) < 3e-4*ax_dist_sq:\n",
    "        continue\n",
    "    shown_images = np.r_[shown_images, [logits_test[i]]]\n",
    "    plt.scatter(logits_test[i,0],logits_test[i,1],c=colors[test_Y[i]])\n",
    "plt.legend(['negative','positive'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax_min = np.min(logits_train,0)\n",
    "ax_max = np.max(logits_train,0)\n",
    "ax_dist_sq = np.sum((ax_max-ax_min)**2)\n",
    "plt.figure(figsize=(8,8))\n",
    "ax = plt.subplot(111)\n",
    "shown_images = np.array([[1., 1.]])\n",
    "colors = ['b','r']\n",
    "for i in range(logits_train.shape[0]):\n",
    "    dist = np.sum((logits_train[i] - shown_images)**2, 1)\n",
    "    if np.min(dist) < 3e-4*ax_dist_sq:\n",
    "        continue\n",
    "    shown_images = np.r_[shown_images, [logits_train[i]]]\n",
    "    plt.scatter(logits_train[i,0],logits_train[i,1],c=colors[train_Y[i]])\n",
    "plt.legend(['negative','positive'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
